// iosfwd standard header
#pragma once
#ifndef _IOSFWD_
#define _IOSFWD_
#ifndef RC_INVOKED
#include <cstdio>
#include <cstring>
#include <cwchar>
#include <xstddef>
#include <crtdbg.h>

#ifdef _MSC_VER
 #pragma pack(push,_CRT_PACKING)
 #pragma warning(push,3)
#endif  /* _MSC_VER */
_STD_BEGIN

		// STREAM POSITIONING TYPES (from <streambuf>)
 #ifdef _WIN64
typedef __int64 streamoff;
typedef __int64 streamsize;

 #else /* _WIN64 */
typedef long streamoff;
typedef int streamsize;
 #endif /* _WIN64 */

 #if defined(_FSEEK_OFF)

 #elif defined(_WIN64)
  #define _FSEEK_OFF(str, off, way)	fseek(str, off, way)

 #else /* _WIN64 */
  #define _FSEEK_OFF(str, off, way)	_fseeki64(str, off, way)
 #endif /* _WIN64 */

#ifdef _M_CEE_PURE
extern fpos_t& _Fpz;
extern const streamoff& _BADOFF;
#else
extern _CRTDATA2 _PGLOBAL fpos_t _Fpz;
extern _CRTDATA2 _PGLOBAL const streamoff _BADOFF;
#endif

		// TEMPLATE CLASS fpos (from <streambuf>)
template<class _Statetype>
	class fpos
	{	// store arbitrary file position
	typedef fpos<_Statetype> _Myt;

public:
	__CLR_OR_THIS_CALL fpos(streamoff _Off = 0)
		: _Myoff(_Off), _Fpos(0), _Mystate(_Stz)
		{	// construct with stream offset
		}

	__CLR_OR_THIS_CALL fpos(_Statetype _State, fpos_t _Fileposition)
		: _Myoff(0), _Fpos(_Fileposition), _Mystate(_State)
		{	// construct with conversion state and C file position
		}

	_Statetype __CLR_OR_THIS_CALL state() const
		{	// return conversion state
		return (_Mystate);
		}

	void __CLR_OR_THIS_CALL state(_Statetype _State)
		{	// set conversion state
		_Mystate = _State;
		}

	fpos_t __CLR_OR_THIS_CALL seekpos() const
		{	// return C file position
		return (_Fpos);
		}

	__CLR_OR_THIS_CALL operator streamoff() const
		{	// return offset
		return ((streamoff)(_Myoff + _FPOSOFF(_Fpos)));
		}

	streamoff __CLR_OR_THIS_CALL operator-(const _Myt& _Right) const
		{	// return difference of file positions as an offset
		return ((streamoff)*this - (streamoff)_Right);
		}

	_Myt& __CLR_OR_THIS_CALL operator+=(streamoff _Off)
		{	// add offset
		_Myoff += _Off;
		return (*this);
		}

	_Myt& __CLR_OR_THIS_CALL operator-=(streamoff _Off)
		{	// subtract offset
		_Myoff -= _Off;
		return (*this);
		}

	_Myt __CLR_OR_THIS_CALL operator+(streamoff _Off) const
		{	// return this + offset
		_Myt _Tmp = *this;
		return (_Tmp += _Off);
		}

	_Myt __CLR_OR_THIS_CALL operator-(streamoff _Off) const
		{	// return this - offset
		_Myt _Tmp = *this;
		return (_Tmp -= _Off);
		}

	bool __CLR_OR_THIS_CALL operator==(const _Myt& _Right) const
		{	// test for file position equality
		return ((streamoff)*this == (streamoff)_Right);
		}

	bool __CLR_OR_THIS_CALL operator!=(const _Myt& _Right) const
		{	// test for file position inequality
		return (!(*this == _Right));
		}

private:
	_PGLOBAL static const _Statetype _Stz;	// initial conversion state
	streamoff _Myoff;	// stream offset
	fpos_t _Fpos;	// C file position
	_Statetype _Mystate;	// current conversion state
	};

	// STATIC fpos::_Stz OBJECT
template<class _Statetype>
	_PGLOBAL const _Statetype fpos<_Statetype>::_Stz = _Statetype();

 #define _POS_TYPE_FROM_STATE(postype, state, position)	\
	postype(state, position)
 #define _POS_TYPE_TO_FPOS_T(pos)	pos.seekpos()
 #define _POS_TYPE_TO_STATE(pos)	pos.state()

typedef fpos<_Mbstatet> streampos;
typedef streampos wstreampos;

		// SECURE CHAR TRAITS TAGS
struct _Unsecure_char_traits_tag
	{
	};
struct _Secure_char_traits_tag
	{
	};

		// TEMPLATE STRUCT _Char_traits_base
		// Used to define the Secure_char_traits tag. This typedef is used
		// only for user defined char_traits. A user defined char_traits should 
		// inherit from _Char_traits_base, define _Secure_char_traits as 
		// _Secure_char_traits_tag and implement _Copy_s and _Move_s.
struct _Char_traits_base
	{
	typedef _Unsecure_char_traits_tag _Secure_char_traits;
	};

		// TEMPLATE STRUCT char_traits (FROM <string>)
		// char_traits classes implement _Copy_s and _Move_s and are
		// automatically recognized as secure by string_base.
template<class _Elem>
	struct char_traits:
		public _Char_traits_base
	{	// properties of a string or stream element
	typedef _Elem char_type;
	typedef long int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef _Mbstatet state_type;

	static void __CLRCALL_OR_CDECL assign(_Elem& _Left, const _Elem& _Right)
		{	// assign an element
		_Left = _Right;
		}

	static bool __CLRCALL_OR_CDECL eq(const _Elem& _Left, const _Elem& _Right)
		{	// test for element equality
		return (_Left == _Right);
		}

	static bool __CLRCALL_OR_CDECL lt(const _Elem& _Left, const _Elem& _Right)
		{	// test if _Left precedes _Right
		return (_Left < _Right);
		}

	static int __CLRCALL_OR_CDECL compare(_In_count_(_Count) const _Elem *_First1,
		_In_count_(_Count) const _Elem *_First2, size_t _Count)
		{	// compare [_First1, _First1 + _Count) with [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		for (; 0 < _Count; --_Count, ++_First1, ++_First2)
			if (!eq(*_First1, *_First2))
				return (lt(*_First1, *_First2) ? -1 : +1);
		return (0);
		}

	static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
		{	// find length of null-terminated sequence
//		_DEBUG_POINTER(_First);
		size_t _Count;
		for (_Count = 0; !eq(*_First, _Elem()); ++_First)
			++_Count;
		return (_Count);
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL copy(_Out_cap_(_Count) _Elem *_First1,
		_In_count_(_Count) const _Elem *_First2, size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Copy_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Copy_s(_Out_cap_(_Dest_size) _Elem *_First1, size_t _Dest_size,
		_In_count_(_Count) const _Elem *_First2, size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_SCL_SECURE_CRT_VALIDATE(_Dest_size >= _Count, NULL);
		_Elem *_Next = _First1;
		for (; 0 < _Count; --_Count, ++_Next, ++_First2)
			assign(*_Next, *_First2);
		return (_First1);
		}

	static const _Elem *__CLRCALL_OR_CDECL find(_In_count_(_Count) const _Elem *_First,
		size_t _Count, const _Elem& _Ch)
		{	// look for _Ch in [_First, _First + _Count)
//		_DEBUG_POINTER(_First);
		for (; 0 < _Count; --_Count, ++_First)
			if (eq(*_First, _Ch))
				return (_First);
		return (0);
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL move(_Out_cap_(_Count) _Elem *_First1,
		_In_count_(_Count) const _Elem *_First2, size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Move_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Move_s(_Out_cap_(_Dest_size) _Elem *_First1, size_t _Dest_size,
		_In_count_(_Count) const _Elem *_First2, size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_SCL_SECURE_CRT_VALIDATE(_Dest_size >= _Count, NULL);
		_Elem *_Next = _First1;
		if (_First2 < _Next && _Next < _First2 + _Count)
			for (_Next += _Count, _First2 += _Count; 0 < _Count; --_Count)
				assign(*--_Next, *--_First2);
		else
			for (; 0 < _Count; --_Count, ++_Next, ++_First2)
				assign(*_Next, *_First2);
		return (_First1);
		}

	static _Elem *__CLRCALL_OR_CDECL assign(_Out_cap_(_Count) _Elem *_First,
		size_t _Count, _Elem _Ch)
		{	// assign _Count * _Ch to [_First, ...)
//		_DEBUG_POINTER(_First);
		_Elem *_Next = _First;
		for (; 0 < _Count; --_Count, ++_Next)
			assign(*_Next, _Ch);
		return (_First);
		}

	static _Elem __CLRCALL_OR_CDECL to_char_type(const int_type& _Meta)
		{	// convert metacharacter to character
		return ((_Elem)_Meta);
		}

	static int_type __CLRCALL_OR_CDECL to_int_type(const _Elem& _Ch)
		{	// convert character to metacharacter
		return ((int_type)_Ch);
		}

	static bool __CLRCALL_OR_CDECL eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	// test for metacharacter equality
		return (_Left == _Right);
		}

	static int_type __CLRCALL_OR_CDECL eof()
		{	// return end-of-file metacharacter
		return ((int_type)EOF);
		}

	static int_type __CLRCALL_OR_CDECL not_eof(const int_type& _Meta)
		{	// return anything but EOF
		return (_Meta != eof() ? (int_type)_Meta : (int_type)!eof());
		}
	};

		// STRUCT char_traits<wchar_t>
template<> struct _CRTIMP2_PURE char_traits<wchar_t>:
	public _Char_traits_base
	{	// properties of a string or stream wchar_t element
	typedef wchar_t _Elem;
	typedef _Elem char_type;	// for overloads
	typedef wint_t int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef _Mbstatet state_type;

	static void __CLRCALL_OR_CDECL assign(_Elem& _Left, const _Elem& _Right)
		{	// assign an element
		_Left = _Right;
		}

	static bool __CLRCALL_OR_CDECL eq(const _Elem& _Left, const _Elem& _Right)
		{	// test for element equality
		return (_Left == _Right);
		}

	static bool __CLRCALL_OR_CDECL lt(const _Elem& _Left, const _Elem& _Right)
		{	// test if _Left precedes _Right
		return (_Left < _Right);
		}

	static int __CLRCALL_OR_CDECL compare(_In_count_(_Count) const _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// compare [_First1, _First1 + _Count) with [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		return (::wmemcmp(_First1, _First2, _Count));
		}

	static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
		{	// find length of null-terminated sequence
//		_DEBUG_POINTER(_First);
		return (::wcslen(_First));
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL copy(_Out_cap_(_Count) _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Copy_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Copy_s(_Out_cap_(_Size_in_words) _Elem *_First1, size_t _Size_in_words, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_CRT_SECURE_WMEMCPY(_First1, _Size_in_words, _First2, _Count);
		return _First1;
		}

	static const _Elem *__CLRCALL_OR_CDECL find(_In_count_(_Count) const _Elem *_First, size_t _Count,
		const _Elem& _Ch)
		{	// look for _Ch in [_First, _First + _Count)
//		_DEBUG_POINTER(_First);
		return ((const _Elem *)::wmemchr(_First, _Ch, _Count));
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL move(_Out_cap_(_Count) _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Move_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Move_s(_Out_cap_(_Size_in_words) _Elem *_First1, size_t _Size_in_words, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_CRT_SECURE_WMEMMOVE(_First1, _Size_in_words, _First2, _Count);
		return (_Elem *)_First1;
		}

	static _Elem *__CLRCALL_OR_CDECL assign(_Out_cap_(_Count) _Elem *_First, size_t _Count, _Elem _Ch)
		{	// assign _Count * _Ch to [_First, ...)
//		_DEBUG_POINTER(_First);
		return ((_Elem *)::wmemset(_First, _Ch, _Count));
		}

	static _Elem __CLRCALL_OR_CDECL to_char_type(const int_type& _Meta)
		{	// convert metacharacter to character
		return (_Meta);
		}

	static int_type __CLRCALL_OR_CDECL to_int_type(const _Elem& _Ch)
		{	// convert character to metacharacter
		return (_Ch);
		}

	static bool __CLRCALL_OR_CDECL eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	// test for metacharacter equality
		return (_Left == _Right);
		}

	static int_type __CLRCALL_OR_CDECL eof()
		{	// return end-of-file metacharacter
		return (WEOF);
		}

	static int_type __CLRCALL_OR_CDECL not_eof(const int_type& _Meta)
		{	// return anything but EOF
		return (_Meta != eof() ? _Meta : !eof());
		}
	};


		// STRUCT char_traits<char> (FROM <string>)
template<> struct _CRTIMP2_PURE char_traits<char>:
	public _Char_traits_base
	{	// properties of a string or stream char element
	typedef char _Elem;
	typedef _Elem char_type;
	typedef int int_type;
	typedef streampos pos_type;
	typedef streamoff off_type;
	typedef _Mbstatet state_type;

	static void __CLRCALL_OR_CDECL assign(_Elem& _Left, const _Elem& _Right)
		{	// assign an element
		_Left = _Right;
		}

	static bool __CLRCALL_OR_CDECL eq(const _Elem& _Left, const _Elem& _Right)
		{	// test for element equality
		return (_Left == _Right);
		}

	static bool __CLRCALL_OR_CDECL lt(const _Elem& _Left, const _Elem& _Right)
		{	// test if _Left precedes _Right
		return (_Left < _Right);
		}

	static int __CLRCALL_OR_CDECL compare(_In_count_(_Count) const _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// compare [_First1, _First1 + _Count) with [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		return (::memcmp(_First1, _First2, _Count));
		}

	static size_t __CLRCALL_OR_CDECL length(_In_z_ const _Elem *_First)
		{	// find length of null-terminated string
//		_DEBUG_POINTER(_First);
		return (::strlen(_First));
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL copy(_Out_cap_(_Count) _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Copy_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Copy_s(_Out_cap_(_Size_in_bytes) _Elem *_First1, size_t _Size_in_bytes, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// copy [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_CRT_SECURE_MEMCPY(_First1, _Size_in_bytes, _First2, _Count);
		return _First1;
		}

	static const _Elem *__CLRCALL_OR_CDECL find(_In_count_(_Count) const _Elem *_First, size_t _Count,
		const _Elem& _Ch)
		{	// look for _Ch in [_First, _First + _Count)
//		_DEBUG_POINTER(_First);
		return ((const _Elem *)::memchr(_First, _Ch, _Count));
		}

	_SCL_INSECURE_DEPRECATE
	static _Elem *__CLRCALL_OR_CDECL move(_Out_cap_(_Count) _Elem *_First1, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
		// assume there is enough space in the destination buffer
		return _Move_s(_First1, _Count, _First2, _Count);
		}

	static _Elem *__CLRCALL_OR_CDECL _Move_s(_Out_cap_(_Size_in_bytes) _Elem *_First1, size_t _Size_in_bytes, _In_count_(_Count) const _Elem *_First2,
		size_t _Count)
		{	// move [_First1, _First1 + _Count) to [_First2, ...)
//		_DEBUG_POINTER(_First1);
//		_DEBUG_POINTER(_First2);
		_CRT_SECURE_MEMMOVE(_First1, _Size_in_bytes, _First2, _Count);
		return _First1;
		}

	static _Elem *__CLRCALL_OR_CDECL assign(_Out_cap_(_Count) _Elem *_First, size_t _Count, _Elem _Ch)
		{	// assign _Count * _Ch to [_First, ...)
//		_DEBUG_POINTER(_First);
		return ((_Elem *)::memset(_First, _Ch, _Count));
		}

	static _Elem __CLRCALL_OR_CDECL to_char_type(const int_type& _Meta)
		{	// convert metacharacter to character
		return ((_Elem)_Meta);
		}

	static int_type __CLRCALL_OR_CDECL to_int_type(const _Elem& _Ch)
		{	// convert character to metacharacter
		return ((unsigned char)_Ch);
		}

	static bool __CLRCALL_OR_CDECL eq_int_type(const int_type& _Left,
		const int_type& _Right)
		{	// test for metacharacter equality
		return (_Left == _Right);
		}

	static int_type __CLRCALL_OR_CDECL eof()
		{	// return end-of-file metacharacter
		return (EOF);
		}

	static int_type __CLRCALL_OR_CDECL not_eof(const int_type& _Meta)
		{	// return anything but EOF
		return (_Meta != eof() ? _Meta : !eof());
		}
	};

		// TEMPLATE FUNCTION _Char_traits_cat
	template <class _Traits>
	class _Inherits_from_char_traits_base
	{
		typedef char _True;
		class _False { char _Dummy[2]; };
		static _True _Inherits(_Char_traits_base);
		static _False _Inherits(...);
		static _Traits _Make_traits();

	public:
		enum { _Exists = sizeof(_Inherits(_Make_traits())) == sizeof(_True) };
	};

	template <class _Traits, bool _Inherits_from_char_traits_base>
	class _Char_traits_category_helper
	{
	public:
		typedef _Unsecure_char_traits_tag _Secure_char_traits;
	};

	// The char_traits class is secure by definition, because we added the _Copy_s and the _Move_s
	// methods.
	template <class _Elem>
	class _Char_traits_category_helper< char_traits<_Elem> , true>
	{
	public:
		typedef _Secure_char_traits_tag _Secure_char_traits;
	};

	template <class _Traits>
	class _Char_traits_category_helper<_Traits, true>
	{
	public:
		typedef typename _Traits::_Secure_char_traits _Secure_char_traits;
	};

	template <class _Traits>
	class _Char_traits_category
	{
	public:
		typedef typename _Char_traits_category_helper<_Traits, _Inherits_from_char_traits_base<_Traits>::_Exists>::_Secure_char_traits _Secure_char_traits;
	};

	// Retrieve the _Secure_char_traits tag from a user defined char_traits
	// methods.
	template<class _Traits> 
	inline
	typename _Char_traits_category<_Traits>::_Secure_char_traits _Char_traits_cat()
	{
		typename _Char_traits_category<_Traits>::_Secure_char_traits _Secure;
		return (_Secure);
	}

	namespace _Traits_helper
	{

		// TEMPLATE FUNCTION _Traits_helper::copy_s
	template<class _Traits>
	inline
	typename _Traits::char_type *copy_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count)
	{
		return copy_s<_Traits>(_First1, _Size, _First2, _Count, _Char_traits_cat<_Traits>());
	}

	template<class _Traits>
	inline
	typename _Traits::char_type *copy_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count, _Secure_char_traits_tag)
	{
		return _Traits::_Copy_s(_First1, _Size, _First2, _Count);
	}

	// If _SECURE_SCL is turned on, the user will get a deprecation warning when calling an unsecure _Traits::copy
	template<class _Traits>
	inline
	_SCL_INSECURE_DEPRECATE
	typename _Traits::char_type *copy_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count, _Unsecure_char_traits_tag)
	{
		return _Traits::copy(_First1, _First2, _Count);
	}

		// TEMPLATE FUNCTION _Traits_helper::move_s
	template<class _Traits>
	inline
	typename _Traits::char_type *move_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count)
	{
		return move_s<_Traits>(_First1, _Size, _First2, _Count, _Char_traits_cat<_Traits>());
	}

	template<class _Traits>
	inline
	typename _Traits::char_type *move_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count, _Secure_char_traits_tag)
	{
		return _Traits::_Move_s(_First1, _Size, _First2, _Count);
	}

	// If _SECURE_SCL is turned on, the user will get a deprecation warning when calling an unsecure _Traits::copy
	template<class _Traits>
	inline
	_SCL_INSECURE_DEPRECATE
	typename _Traits::char_type *move_s(_Out_cap_(_Size) typename _Traits::char_type *_First1, size_t _Size,
		_In_count_(_Count) const typename _Traits::char_type *_First2, size_t _Count, _Unsecure_char_traits_tag)
	{
		return _Traits::move(_First1, _First2, _Count);
	}

	} // namespace _Traits_helper

		// FORWARD REFERENCES
template<class _Ty>
	class allocator;
class ios_base;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ios;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class istreambuf_iterator;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class ostreambuf_iterator;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_streambuf;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_istream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ostream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_iostream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_stringbuf;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_istringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_ostringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem>,
	class _Alloc = allocator<_Elem> >
	class basic_stringstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_filebuf;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ifstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_ofstream;
template<class _Elem,
	class _Traits = char_traits<_Elem> >
	class basic_fstream;

 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
template<class _Elem,
	class _InIt >
	class num_get;
template<class _Elem,
	class _OutIt >
	class num_put;
template<class _Elem>
	class collate;
 #endif /* _DLL_CPPLIB */

		// char TYPEDEFS
typedef basic_ios<char, char_traits<char> > ios;
typedef basic_streambuf<char, char_traits<char> > streambuf;
typedef basic_istream<char, char_traits<char> > istream;
typedef basic_ostream<char, char_traits<char> > ostream;
typedef basic_iostream<char, char_traits<char> > iostream;
typedef basic_stringbuf<char, char_traits<char>,
	allocator<char> > stringbuf;
typedef basic_istringstream<char, char_traits<char>,
	allocator<char> > istringstream;
typedef basic_ostringstream<char, char_traits<char>,
	allocator<char> > ostringstream;
typedef basic_stringstream<char, char_traits<char>,
	allocator<char> > stringstream;
typedef basic_filebuf<char, char_traits<char> > filebuf;
typedef basic_ifstream<char, char_traits<char> > ifstream;
typedef basic_ofstream<char, char_traits<char> > ofstream;
typedef basic_fstream<char, char_traits<char> > fstream;

		// wchat_t TYPEDEFS
typedef basic_ios<wchar_t, char_traits<wchar_t> > wios;
typedef basic_streambuf<wchar_t, char_traits<wchar_t> >
	wstreambuf;
typedef basic_istream<wchar_t, char_traits<wchar_t> > wistream;
typedef basic_ostream<wchar_t, char_traits<wchar_t> > wostream;
typedef basic_iostream<wchar_t, char_traits<wchar_t> > wiostream;
typedef basic_stringbuf<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wstringbuf;
typedef basic_istringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wistringstream;
typedef basic_ostringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wostringstream;
typedef basic_stringstream<wchar_t, char_traits<wchar_t>,
	allocator<wchar_t> > wstringstream;
typedef basic_filebuf<wchar_t, char_traits<wchar_t> > wfilebuf;
typedef basic_ifstream<wchar_t, char_traits<wchar_t> > wifstream;
typedef basic_ofstream<wchar_t, char_traits<wchar_t> > wofstream;
typedef basic_fstream<wchar_t, char_traits<wchar_t> > wfstream;



 #if defined(_DLL_CPPLIB) && !defined(_M_CEE_PURE)
typedef num_get<char, istreambuf_iterator<char, char_traits<char> > >
	numget;
typedef num_get<wchar_t, istreambuf_iterator<wchar_t, char_traits<wchar_t> > >
	wnumget;
typedef num_put<char, ostreambuf_iterator<char, char_traits<char> > >
	numput;
typedef num_put<wchar_t, ostreambuf_iterator<wchar_t, char_traits<wchar_t> > >
	wnumput;
typedef collate<char> ncollate;
typedef collate<wchar_t> wcollate;
 #endif /* _DLL_CPPLIB */

_STD_END

#ifdef _MSC_VER
 #pragma warning(pop)
 #pragma pack(pop)
#endif  /* _MSC_VER */

#endif /* RC_INVOKED */
#endif /* _IOSFWD_ */

/*
 * Copyright (c) 1992-2008 by P.J. Plauger.  ALL RIGHTS RESERVED.
 * Consult your license regarding permissions and restrictions.
 V5.05:0009 */
